from libavg import avg
from config import Config
from display import Display
from trash import Trash

from dragableTrash import DragableTrash
from pinchableTrash import PinchableTrash
from doubleclickTrash import DoubleclickTrash

from board import Board
from panels.wind import WindPanel
from panels.score import ScoreScreen
import random

# IMPORTE

class Simulator:
    
    trash_list = ("beer_720.png", "box_720.png", "tv_720.png") # BILDERAUSWAHL DER FALLENDEN OBJEKTE
    trash_cnt = len(trash_list) # LAENGE DER BILDERAUSWAHL
    __player1Dead = False # FLAG OB SPIELER 1 TOT IST
    __player2Dead = False # FLAG OB SPIELER 2 TOT IST
    __cnt = 0 # ZAEHLER DER ITERATION FUER TIMER
    
    def __init__(self,size,parentN): # KONSTRUKTOR
        self.__display = Display(size,parentN); # DISPLAY WIRD GEBAUT
        
    def start(self): # STARTE SIMULATOR
        self.__trashLeft = avg.Player.get().setInterval(100,self.step) # call step all 100ms

    def step(self): # METHODE STEP
        if(not self.__player1Dead or not self.__player2Dead): # FALLS NOCH EIN SPILER LEBT
            self.__cnt += 1 # ERHOEHE ITERATIONSZAEHLER
            
            # TESTE OB FALLENDES OBJEKT BODEN ODER WINDRAD GETROFFEN HAT
            # FUER RECHTE SEITE
            self.checkForCollision(self.__display.boardRight, self.__display.pointsBarRight, False)
            
            # FUER LINKE SEITE
            self.checkForCollision(self.__display.boardLeft, self.__display.pointsBarLeft, True)
            
            # FALLS BEIDE TOT ZEIGE PUNKTE-BILDSCHIRM
            if(self.__player1Dead and self.__player2Dead):
                self.loadScores()
            
            # produce trash every 1500 ms
            if self.__cnt % 15 == 0 :
                self.produceTrash(self.__display.boardLeft) # AUF LINKER SEITE
                self.produceTrash(self.__display.boardRight) # AUF RECHTER SEITE
            
            # update wind direction every 2000 ms
            if self.__cnt % 20 == 0 :
                self.updateWindDirection()
                
            # SETZE ITERATIONSZAEHLER AUF 0 BEI 10000
            if self.__cnt == 10000 :
                self.__cnt == 0
             
    def updateWindDirection(self):
        self.__randInt = random.randint(-3, 3) # WUERFELE ZUFALLSZAHL VON -3 bis 3         
        self.__display.windPanel.setDirection(self.__randInt) # SETZE WINDRICHTUNG AUF ZUFALLSZAHL  


    #loading the score screen
    def loadScores(self):
        screen =ScoreScreen(self.__display, self.__display.pointsBarLeft, self.__display.pointsBarRight)
        
        
    def produceTrash(self, board):
        # random trash
        trash_id = random.randint(0, Simulator.trash_cnt -1)   
        
        newTrash = self.chooseTrash(board) # WAEHLE MUELL 
        
        # random for initial position
        position = random.randint(0, 620) - 10
        
        # add trash 
        board.addTrash(newTrash) # in LISTE VON BOARD
        
        newTrash.fallDown(self.__display.windPanel.getDirectionVector())
    
    def chooseTrash(self,board):
        w = random.randint(0,2) # WUERFELE ZUFALLSZAHL
        if w == 0: # ABHAENGIG VON ZUFALLSZAHL
          return DoubleclickTrash(200, board, 6, Simulator.trash_list[1]) # BAUE TYP 1
        elif w==1:
            return DragableTrash(200, board, 3, Simulator.trash_list[0])  # BAUE TYP 2
        else:
            return PinchableTrash(200, board, 2, Simulator.trash_list[2]) # BAUE TYP 3     
            
    def checkForCollision(self,board,bar, isLeft):
        allTrash = board.getTrashList() # NIMM MUELLLISTE AUS BOARD

        collisionlist = [] # INITIALISIERE KOLLISIONSLISTE
        for trash in allTrash: # FUER JEDES OBJEKT IN MUELLISTE

            if trash.updateable(): # FALLS BENUTZER NICHT MIT OBJEKT INTERAGIERT
                trash.fallDown(self.__display.windPanel.getDirectionVector()) # SETZE WINDRICHTUNG BEI OBJEKT
            if board.collided(trash) == Board.WHEEL_COLLISION: # FALLS OBJEKT MIT WINDRAD KOLLIDIERT
                bar.decrementCondition(trash.getWeight()) # ZIEHE VOM ZUSTAND DEN WERT DES GEWICHTS DES OBJEKTS AB
                collisionlist.append(trash) # FUEGE OBJEKTE IN KOLLISIONSLISTE
                if bar.getCondition() <= 0: # FALLS ZUSTAND <= 0 
                    bar.setCondition(0) # SETZE ZUSTAND AUF 0 ,  ZUSTAND NICHT NEGATIV
                    if(isLeft): # FALLS LINKER SPIELER
                        self.__player1Dead = True # SETZE FLAG FUER SPIELER 1 TOT AUF TRUE
                    else:
                        self.__player2Dead = True # SETZE FLAG FUER SPIELER 2 TOT AUF TRUE
                    allTrash = None # MUELLISTE LEEREN
                    board.active = False # DEAKTIVIERE BOARD
            elif board.collided(trash) == Board.GROUND_COLLISION: # FALLS OBJEKTE MIT BODEN KOLLIDIERT
                collisionlist.append(trash) # ZUR KOLLISIONSLISTE HINZUFUEGEN

        for t in collisionlist:
            t.fadeOut(); # JEDES OBJEKTE IN KOLLISIONSLISTE LOESCHEN
